home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / private / pdcutil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  16.1 KB  |  565 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22. #undef PDC_usleep
  23.  
  24. #if defined(DOS) && defined(MSC) || defined(XCURSES)
  25. #include <time.h>
  26. #endif
  27.  
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include <ctype.h>
  31. #include <stdio.h>
  32. #include <stdarg.h>
  33. #include <limits.h>
  34. #include <signal.h>
  35.  
  36. #ifdef PDCDEBUG
  37. char *rcsid_PDCutil  = "$Id$";
  38. #endif
  39.  
  40. /*man-start*********************************************************************
  41.  
  42.   PDC_memmove()    - Replacement memmove() for lacking compliers.
  43.  
  44.   PDCurses Description:
  45.      This is a private PDCurses routine.
  46.  
  47.      Move a portion of memory taking consideration of overlapping memory
  48.      areas.
  49.  
  50.   PDCurses Return Value:
  51.      This function returns NULL if no temporary memory could be allocated.
  52.  
  53.   Portability:
  54.      PDCurses    int PDC_memmove(void *s1,const void *s2,size_t n);
  55.  
  56. **man-end**********************************************************************/
  57.  
  58.  
  59. void *PDC_memmove (void *s1, const void *s2, size_t n)
  60. {
  61.   char *dd=NULL;
  62.   const char *ss=NULL;
  63.  
  64.   dd = (char *)s1;
  65.   ss = (const char *)s2;
  66.   if (dd > ss && dd < ss + n)
  67.     {
  68.       dd += n;
  69.       ss += n;
  70.       while (n--)
  71.         *--dd = *--ss;
  72.     }
  73.   else
  74.     while (n--)
  75.       *dd++ = *ss++;
  76.   return s1;
  77. }
  78.  
  79. /*man-start*********************************************************************
  80.  
  81.   PDC_usleep()    - waits for specified number of microseconds
  82.  
  83.   PDCurses Description:
  84.      This routine is intended to provide a mechanism to wait the
  85.      specified number of microseconds. This routine is provided for
  86.      users of the Microsoft compilers under DOS as the default
  87.      library does not provide a suitable function.
  88.      Under any other Operating System/Compiler option, this function
  89.      does nothing.
  90.  
  91.   Portability:
  92.      PDCurses    void PDC_usleep( clock_t );
  93.  
  94.   Acknowledgement
  95.      PDC_usleep() was written by John Steele  (jsteele@netcom.com)
  96.  
  97. **man-end**********************************************************************/
  98.  
  99. #if defined(DOS) && defined(MSC)
  100. void    PDC_usleep(clock_t wait)
  101. {
  102.     clock_t goal;
  103. #ifdef PDCDEBUG
  104.     if (trace_on) PDC_debug("PDC_usleep() - called\n");
  105. #endif
  106.  
  107.     goal = wait + clock();
  108.     while (goal > clock())
  109.     ;
  110.     return;
  111. }
  112. #endif
  113.  
  114. #if defined(XCURSES) && defined(HAS_POLL)
  115. # include <poll.h>
  116. void    PDC_usleep(long wait)
  117. {
  118.     struct pollfd fd;
  119. #ifdef PDCDEBUG
  120.     if (trace_on) PDC_debug("PDC_usleep() - called\n");
  121. #endif
  122.     poll(&fd,0L,wait);
  123.     return;
  124. }
  125. #endif
  126.  
  127. #if defined(XCURSES) && defined(HAS_USLEEP)
  128. void    PDC_usleep(long wait)
  129. {
  130. #ifdef PDCDEBUG
  131.     if (trace_on) PDC_debug("PDC_usleep() - called\n");
  132. #endif
  133.     usleep(wait);
  134.     return;
  135. }
  136. #endif
  137.  
  138. /*
  139.  * This module is based on vsscanf.c and input.c from emx 0.8f library
  140.  * source which is Copyright (c) 1990-1992 by Eberhard Mattes.
  141.  * Eberhard Mattes has kindly agreed to allow this module to be incorporated
  142.  * into PDCurses.
  143.  */
  144.  
  145. /*man-start*********************************************************************
  146.  
  147.   PDC_vsscanf()    - Internal routine to parse and format an input buffer.
  148.  
  149.   PDCurses Description:
  150.      This is a private PDCurses routine.
  151.  
  152.      Scan a series of input fields. Each field is formatted according to
  153.      a supplied format string and the formatted input is stored in the
  154.      variable number of addresses passed.
  155.  
  156.   PDCurses Return Value:
  157.      This function returns the number of input fields or EOF on error.
  158.  
  159.   PDCurses Errors:
  160.      If the supplied data is invalid or an incorrect number of arguments
  161.      are passed, EOF is returned as an error.
  162.  
  163.   Portability:
  164.      PDCurses    int PDC_vsscanf(char *buf,const char *fmt,va_list arg_ptr);
  165.  
  166. **man-end**********************************************************************/
  167.  
  168. #define WHITE(x) ((x) == ' ' || (x) == '\t' || (x) == '\n')
  169.  
  170. #define NEXT(x) \
  171.         do { \
  172.             x = *buf++; \
  173.             if (x == '\0') \
  174.                return (count == 0 ? EOF : count); \
  175.             ++chars; \
  176.            } while (0)
  177.  
  178. #define UNGETC(x) \
  179.         do { \
  180.             --buf; *buf = x; --chars; \
  181.            } while (0)
  182.  
  183. int PDC_vsscanf ( char *buf, const char *fmt, char *arg_ptr)
  184. {
  185.     int count, chars, c, width, radix, d, i;
  186.     int *int_ptr;
  187.     long *long_ptr;
  188.     short *short_ptr;
  189.     char *char_ptr;
  190.     unsigned char f;
  191.     char neg, assign, ok, size;
  192.     unsigned long n;
  193.     char map[256], end;
  194.     double dx, dd, *dbl_ptr;
  195.     float *flt_ptr;
  196.     int exp;
  197.     char eneg;
  198.  
  199. #ifdef PDCDEBUG
  200. #define bool unsigned char
  201.     extern bool trace_on; /* this is explicit here as curses.h is not #included */
  202.     if (trace_on) PDC_debug("PDC_vsscanf() - called\n");
  203. #endif
  204.  
  205.   count = 0; chars = 0; c = 0;
  206.   while ((f = *fmt) != 0)
  207.     {
  208.       if (WHITE (f))
  209.         {
  210.           do
  211.             {
  212.               ++fmt; f = *fmt;
  213.             } while (WHITE (f));
  214.           do
  215.             {
  216.               c = *buf++;
  217.               if (c == '\0')
  218.                 {
  219.                   if (f == 0 || count != 0)
  220.                     return (count);
  221.                   else
  222.                     return (EOF);
  223.                 }
  224.               else
  225.                 ++chars;
  226.             } while (WHITE (c));
  227.           UNGETC (c);
  228.         }
  229.       else if (f != '%')
  230.         {
  231.           NEXT (c);
  232.           if (c != f)
  233.             return (count);
  234.           ++fmt;
  235.         }
  236.       else
  237.         {
  238.           assign = TRUE; width = INT_MAX;
  239.           char_ptr = NULL;
  240.           ++fmt;
  241.           if (*fmt == '*')
  242.             {
  243.               assign = FALSE;
  244.               ++fmt;
  245.             }
  246.           if (isdigit (*fmt))
  247.             {
  248.               width = 0;
  249.               while (isdigit (*fmt))
  250.                 width = width * 10 + (*fmt++ - '0');
  251.               if (width == 0) width = INT_MAX;
  252.             }
  253.           size = 0;
  254.           if (*fmt == 'h' || *fmt == 'l')
  255.             size = *fmt++;
  256.           f = *fmt;
  257.           switch (f)
  258.             {
  259.             case 'c':
  260.               if (width == INT_MAX)
  261.                 width = 1;
  262.               if (assign)
  263.                 char_ptr = va_arg (arg_ptr, char *);
  264.               while (width > 0)
  265.                 {
  266.                   --width;
  267.                   NEXT (c);
  268.                   if (assign)
  269.                     {
  270.                       *char_ptr++ = (char)c;
  271.                       ++count;
  272.                     }
  273.                 }
  274.               break;
  275.             case '[':
  276.               (void)memset (map, 0, 256);
  277.               end = 0;
  278.               ++fmt;
  279.               if (*fmt == '^')
  280.                 {
  281.                   ++fmt; end = 1;
  282.                 }
  283.               i = 0;
  284.               for (;;)
  285.                 {
  286.                   f = (unsigned char)*fmt;
  287.                   switch (f)
  288.                     {
  289.                     case 0:
  290.                       --fmt;       /* avoid skipping past 0 */
  291.                       NEXT (c);
  292.                       goto string;
  293.                     case ']':
  294.                       if (i > 0)
  295.                         {
  296.                           NEXT (c);
  297.                           goto string;
  298.                         }
  299.                       /* no break */
  300.                     default:
  301.                       if (fmt[1] == '-' && fmt[2] != 0 &&
  302.                           f < (unsigned char)fmt[2])
  303.                         {
  304.                           (void)memset (map+f, 1, (unsigned char)fmt[2]-f);
  305.                           fmt += 2;
  306.                         }
  307.                       else
  308.                         map[f] = 1;
  309.                       break;
  310.                     }
  311.                   ++fmt; ++i;
  312.                 }
  313.             case 's':
  314.               (void)memset (map, 0, 256);
  315.               map[' '] = 1;
  316.               map['\n'] = 1;
  317.               map['\r'] = 1;
  318.               map['\t'] = 1;
  319.               end = 1;
  320.               do
  321.                 {
  322.                   NEXT (c);
  323.                 } while (WHITE (c));
  324. string:
  325.               if (assign)
  326.                 char_ptr = va_arg (arg_ptr, char *);
  327.               while (width > 0 && map[(unsigned char)c] != end)
  328.                 {
  329.                   --width;
  330.                   if (assign)
  331.                     *char_ptr++ = (char)c;
  332.                   c = *buf++;
  333.                   if (c == '\0')
  334.                     break;
  335.                   else
  336.                     ++chars;
  337.                 }
  338.               if (assign)
  339.                 {
  340.                   *char_ptr = 0;
  341.                   ++count;
  342.                 }
  343.               if (c == '\0')
  344.                 return (count);
  345.               else
  346.                 UNGETC (c);
  347.               break;
  348.             case 'f':
  349.             case 'e':
  350.             case 'E':
  351.             case 'g':
  352.             case 'G':
  353.               neg = ok = FALSE; dx = 0.0;
  354.               do
  355.                 {
  356.                   NEXT (c);
  357.                 } while (WHITE (c));
  358.               if (c == '+')
  359.                 {
  360.                   NEXT (c); --width;
  361.                 }
  362.               else if (c == '-')
  363.                 {
  364.                   neg = TRUE; NEXT (c); --width;
  365.                 }
  366.               while (width > 0 && isdigit (c))
  367.                 {
  368.                   --width;
  369.                   dx = dx * 10.0 + (double)(c - '0');
  370.                   ok = TRUE;
  371.                   c = *buf++;
  372.                   if (c == '\0')
  373.                     break;
  374.                   else
  375.                     ++chars;
  376.                 }
  377.               if (width > 0 && c == '.')
  378.                 {
  379.                   --width;
  380.                   dd = 10.0; NEXT (c);
  381.                   while (width > 0 && isdigit (c))
  382.                     {
  383.                       --width;
  384.                       dx += (double)(c - '0') / dd;
  385.                       dd *= 10.0;
  386.                       ok = TRUE;
  387.                       c = *buf++;
  388.                       if (c == '\0')
  389.                         break;
  390.                       else
  391.                         ++chars;
  392.                     }
  393.                 }
  394.               if (!ok)
  395.                 return (count);
  396.               if (width > 0 && (c == 'e' || c == 'E'))
  397.                 {
  398.                   eneg = FALSE; exp = 0; NEXT (c); --width;
  399.                   if (width > 0 && c == '+')
  400.                     {
  401.                       NEXT (c); --width;
  402.                     }
  403.                   else if (width > 0 && c == '-')
  404.                     {
  405.                       eneg = TRUE; NEXT (c); --width;
  406.                     }
  407.                   if (!(width > 0 && isdigit (c)))
  408.                     {
  409.                       UNGETC (c);
  410.                       return (count);
  411.                     }
  412.                   while (width > 0 && isdigit (c))
  413.                     {
  414.                       --width;
  415.                       exp = exp * 10 + (c - '0');
  416.                       c = *buf++;
  417.                       if (c == '\0')
  418.                         break;
  419.                       else
  420.                         ++chars;
  421.                     }
  422.                   if (eneg) exp = -exp;
  423.                   while (exp > 0)
  424.                     {
  425.                       dx *= 10.0;
  426.                       --exp;
  427.                     }
  428.                   while (exp < 0)
  429.                     {
  430.                       dx /= 10.0;
  431.                       ++exp;
  432.                     }
  433.                 }
  434.               if (assign)
  435.                 {
  436.                   if (neg) dx = -dx;
  437.                   if (size == 'l')
  438.                     {
  439.                       dbl_ptr = va_arg (arg_ptr, double *);
  440.                       *dbl_ptr = dx;
  441.                     }
  442.                   else
  443.                     {
  444.                       flt_ptr = va_arg (arg_ptr, float *);
  445.                       *flt_ptr = (float)dx;
  446.                     }
  447.                   ++count;
  448.                 }
  449.               if (c == '\0')
  450.                 return (count);
  451.               else
  452.                 UNGETC (c);
  453.               break;
  454.             case 'i':
  455.               neg = FALSE; radix = 10;
  456.               do
  457.                 {
  458.                   NEXT (c);
  459.                 } while (WHITE (c));
  460.               if (!(width > 0 && c == '0'))
  461.                 goto scan_complete_number;
  462.               NEXT (c); --width;
  463.               if (width > 0 && (c == 'x' || c == 'X'))
  464.                 {
  465.                   NEXT (c); radix = 16; --width;
  466.                 }
  467.               else if (width > 0 && (c >= '0' && c <= '7'))
  468.                 radix = 8;
  469.               goto scan_unsigned_number;
  470.             case 'd':
  471.             case 'u':
  472.             case 'o':
  473.             case 'x':
  474.             case 'X':
  475.               do
  476.                 {
  477.                   NEXT (c);
  478.                 } while (WHITE (c));
  479.               switch (f)
  480.                 {
  481.                 case 'o':           radix = 8; break;
  482.                 case 'x': case 'X': radix = 16; break;
  483.                 default:            radix = 10; break;
  484.                 }
  485. scan_complete_number:
  486.               neg = FALSE;
  487.               if (width > 0 && c == '+')
  488.                 {
  489.                   NEXT (c); --width;
  490.                 }
  491.               else if (width > 0 && c == '-' && radix == 10)
  492.                 {
  493.                   neg = TRUE; NEXT (c); --width;
  494.                 }
  495. scan_unsigned_number:
  496.               n = 0; ok = FALSE;
  497.               while (width > 0)
  498.                 {
  499.                   --width;
  500.                   if (isdigit (c))
  501.                     d = c - '0';
  502.                   else if (isupper (c))
  503.                     d = c - 'A' + 10;
  504.                   else if (islower (c))
  505.                     d = c - 'a' + 10;
  506.                   else
  507.                     break;
  508.                   if (d < 0 || d >= radix)
  509.                     break;
  510.                   ok = TRUE;
  511.                   n = n * radix + d;
  512.                   c = *buf++;
  513.                   if (c == '\0')
  514.                     break;
  515.                   else
  516.                     ++chars;
  517.                 }
  518.               if (!ok)
  519.                 return (count);
  520.               if (assign)
  521.                 {
  522.                   if (neg) n = -n;
  523.                   switch(size)
  524.                      {
  525.                       case 'h':
  526.                               short_ptr = va_arg (arg_ptr, short *);
  527.                               *short_ptr = (short)n;
  528.                               break;
  529.                       case 'l':
  530.                               long_ptr = va_arg (arg_ptr, long *);
  531.                               *long_ptr = (long)n;
  532.                               break;
  533.                       default:
  534.                               int_ptr = va_arg (arg_ptr, int *);
  535.                               *int_ptr = (int)n;
  536.                      }
  537.                   ++count;
  538.                 }
  539.               if (c == '\0')
  540.                 return (count);
  541.               else
  542.                 UNGETC (c);
  543.               break;
  544.             case 'n':
  545.               if (assign)
  546.                 {
  547.                   int_ptr = va_arg (arg_ptr, int *);
  548.                   *int_ptr = chars;
  549.                   ++count;
  550.                 }
  551.               break;
  552.             default:
  553.               if (f == 0)                 /* % at end of string */
  554.                 return (count);
  555.               NEXT (c);
  556.               if (c != f)
  557.                 return (count);
  558.               break;
  559.             }
  560.           ++fmt;
  561.         }
  562.     }
  563.   return (count);
  564. }
  565.